 /**
 * 筛选器工具函数
 * 提供统一的筛选器显示逻辑和标签生成
 */

/**
 * 获取值的显示文本
 * @param {Object} filterItem 筛选项配置
 * @param {any} value 筛选值
 * @returns {string} 显示文本
 */
export function getValueDisplayText(filterItem, value) {
    // 空值处理
    if (value === null || value === undefined || value === '') {
      return '';
    }
  
    // 数组值处理
    if (Array.isArray(value)) {
      if (value.length === 0) return '';
      
      // 范围类型特殊处理
      if (filterItem.type === 'date-range' && value.length === 2) {
        return `${value[0]} 至 ${value[1]}`;
      }
      
      if (filterItem.type === 'number-range' && value.length === 2) {
        return `${value[0]} - ${value[1]}`;
      }
      
      // 多选类型
      if (filterItem.type === 'multi-select') {
        return value.map(val => {
          const option = filterItem.options?.find(opt => opt.value === val);
          return option ? option.label : val;
        }).join(', ');
      }
      
      return `${value.length}项`;
    }
  
    // 单选类型
    if (filterItem.type === 'select' || filterItem.type === 'multi-select') {
      const option = filterItem.options?.find(opt => opt.value === value);
      return option ? option.label : String(value);
    }
  
    // 自定义格式化函数
    if (filterItem.formatter && typeof filterItem.formatter === 'function') {
      return filterItem.formatter(value);
    }
  
    return String(value);
  }
  
  /**
   * 获取筛选项显示值
   * @param {Object} filterItem 筛选项配置
   * @param {Object} filterValues 所有筛选值
   * @returns {string} 显示值
   */
  export function getFilterDisplayValue(filterItem, filterValues) {
    const value = filterValues[filterItem.key];
    
    if (!value || (Array.isArray(value) && value.length === 0)) {
      return '';
    }
    
    return getValueDisplayText(filterItem, value);
  }
  
  /**
   * 生成筛选器标签
   * @param {Array} filterItems 筛选项配置数组
   * @param {Object} filterValues 筛选值对象
   * @returns {Array} 标签数组
   */
  export function generateFilterTags(filterItems, filterValues) {
    const tags = [];
    
    Object.entries(filterValues).forEach(([key, value]) => {
      if (!value || (Array.isArray(value) && value.length === 0)) return;
      
      const filterItem = filterItems.find(item => item.key === key);
      if (!filterItem) return;
  
      // 处理范围类型（作为整体显示）
      if (filterItem.type === 'date-range' || filterItem.type === 'number-range') {
        if (Array.isArray(value) && value.length === 2) {
          const displayValue = getValueDisplayText(filterItem, value);
          tags.push({
            key,
            value,
            label: `${filterItem.label}: ${displayValue}`,
            type: 'range'
          });
        }
      }
      // 处理多选类型（每个选项单独显示）
      else if (filterItem.type === 'multi-select' && Array.isArray(value)) {
        value.forEach(val => {
          const displayValue = getValueDisplayText(filterItem, val);
          tags.push({
            key,
            value: val,
            label: `${filterItem.label}: ${displayValue}`,
            type: 'multi-select'
          });
        });
      } 
      // 处理单选类型
      else {
        const displayValue = getValueDisplayText(filterItem, value);
        tags.push({
          key,
          value,
          label: `${filterItem.label}: ${displayValue}`,
          type: 'single'
        });
      }
    });
    
    return tags;
  }
  
  /**
   * 检查是否有活跃的筛选条件
   * @param {Object} filterValues 筛选值对象
   * @returns {boolean} 是否有活跃筛选条件
   */
  export function hasActiveFilters(filterValues) {
    return Object.values(filterValues).some(value => {
      if (Array.isArray(value)) return value.length > 0;
      return value !== null && value !== undefined && value !== '';
    });
  }
  
  /**
   * 计算活跃筛选条件数量
   * @param {Object} filterValues 筛选值对象
   * @returns {number} 活跃筛选条件数量
   */
  export function getActiveFilterCount(filterValues) {
    return Object.values(filterValues).filter(value => {
      if (Array.isArray(value)) return value.length > 0;
      return value !== null && value !== undefined && value !== '';
    }).length;
  }
  
  /**
   * 清空单个筛选条件
   * @param {Object} filterValues 筛选值对象（会被修改）
   * @param {string} key 要清空的筛选键
   * @param {any} value 要移除的特定值（用于多选）
   * @param {Array} filterItems 筛选项配置数组
   */
  export function clearSingleFilter(filterValues, key, value, filterItems) {
    const filterItem = filterItems.find(item => item.key === key);
    const currentValue = filterValues[key];
    
    // 处理范围类型 - 直接清空整个范围
    if (filterItem && (filterItem.type === 'date-range' || filterItem.type === 'number-range')) {
      filterValues[key] = null;
    }
    // 处理多选类型 - 移除特定值
    else if (filterItem && filterItem.type === 'multi-select' && Array.isArray(currentValue)) {
      const index = currentValue.indexOf(value);
      if (index > -1) {
        currentValue.splice(index, 1);
      }
    } 
    // 处理单选类型 - 清空值
    else {
      filterValues[key] = null;
    }
  }
  
  /**
   * 清空所有筛选条件
   * @param {Object} filterValues 筛选值对象（会被修改）
   * @param {Array} filterItems 筛选项配置数组
   */
  export function clearAllFilters(filterValues, filterItems) {
    Object.keys(filterValues).forEach(key => {
      const filterItem = filterItems.find(item => item.key === key);
      if (filterItem?.type === 'multi-select') {
        filterValues[key] = [];
      } else {
        filterValues[key] = null;
      }
    });
  }
  
  /**
   * 获取筛选器组件名称
   * @param {string} type 筛选器类型
   * @returns {string} 组件名称
   */
  export function getFilterComponentName(type) {
    const componentMap = {
      'select': 'c-select-sheet',
      'multi-select': 'c-multi-select-sheet',
      'date-range': 'c-date-range-sheet',
      'number-range': 'c-number-range-sheet',
      'date': 'c-date-sheet',
      'time': 'c-time-sheet'
    };
    return componentMap[type] || 'c-select-sheet';
  }